/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.dp1.pucp.Produccion.Controlador;

import com.dp1.pucp.Administracion.DAO.RRHHDAO;
import com.dp1.pucp.Logistica.DAO.TipoProductoDAO;

import com.dp1.pucp.Modelo.Clases.Almacen;

import com.dp1.pucp.Modelo.Algoritmos.EmpleadoAlgoritmo;

import com.dp1.pucp.Modelo.Clases.Demanda;
import com.dp1.pucp.Modelo.Clases.Demandaxpedidoproducto;
import com.dp1.pucp.Modelo.Clases.Empleado;
import com.dp1.pucp.Modelo.Clases.Empleadoxmaquinasimulacion;
import com.dp1.pucp.Modelo.Clases.Historico;
import com.dp1.pucp.Modelo.Clases.Kardex;
import com.dp1.pucp.Modelo.Clases.Lineapedidoproducto;
import com.dp1.pucp.Modelo.Clases.Maquina;
import com.dp1.pucp.Modelo.Clases.Materiaprima;
import com.dp1.pucp.Modelo.Clases.Pedidoproduccion;
import com.dp1.pucp.Modelo.Clases.Pedidoproducto;
import com.dp1.pucp.Modelo.Clases.Presentacion;
import com.dp1.pucp.Modelo.Clases.Productofinal;
import com.dp1.pucp.Modelo.Clases.Productointermedio;
import com.dp1.pucp.Modelo.Clases.Productosimulacion;
import com.dp1.pucp.Modelo.Clases.RecetaPfMp;
import com.dp1.pucp.Modelo.Clases.Simulacion;
import com.dp1.pucp.Modelo.Clases.Superhombre;
import com.dp1.pucp.Modelo.Clases.Tipomerma;
import com.dp1.pucp.Modelo.Clases.Tipoproducto;
import com.dp1.pucp.Modelo.Clases.Trabajo;
import com.dp1.pucp.Produccion.DAO.ProduccionDAO;
import com.dp1.pucp.Produccion.Vista.DetalleAsignacionGUI;
import com.dp1.pucp.Produccion.Vista.RegResultadosGUI;
import com.dp1.pucp.Simulacion.DAO.SimulacionDAO;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import javax.swing.JFrame;
import javax.swing.table.DefaultTableModel;

/**
 *
 * @author Rodrigo
 */
public class RegResultadosControlador {
    
    private RegResultadosGUI regResultadosView;
    private Simulacion simulacion;
    private ArrayList<Trabajo> arregloTrabajos;
    private ArrayList<Empleadoxmaquinasimulacion> listaEmpleadoxMaquina;
    private ArrayList<EmpleadoAlgoritmo> arregloEmpleados;
    
    public RegResultadosControlador(RegResultadosGUI regResultadosView,Simulacion simulacion){
        
        this.regResultadosView=regResultadosView;
        this.simulacion=simulacion;
        this.regResultadosView.addCerrarListener(new cerrarListener());
        this.regResultadosView.addGuardarListener(new guardarListener());
        ProduccionDAO dao = new ProduccionDAO();
        listaEmpleadoxMaquina=dao.listarEmpleadoMaquinaSimulacion(simulacion);
        this.regResultadosView.setTurno(simulacion.getTurno());

         arregloEmpleados = new ArrayList<EmpleadoAlgoritmo>();

        creaEmpleadosAlgoritmo(arregloEmpleados);
        
        leerHistoricos2(arregloEmpleados);
        actualizarTabla();
        
        
    }
    
    public void creaEmpleadosAlgoritmo(ArrayList<EmpleadoAlgoritmo> arregloEmpleados){

        for (int i=0; i<listaEmpleadoxMaquina.size();i++){
            EmpleadoAlgoritmo emp = new EmpleadoAlgoritmo();
            emp.setIdempleado(listaEmpleadoxMaquina.get(i).getEmpleado().getIdempleado());
            emp.setTipoMaquinaAsignada(listaEmpleadoxMaquina.get(i).getMaquina().getTipomaquina().getIdtipomaquina());
            emp.setTurno(simulacion.getTurno());
            arregloEmpleados.add(emp);
        } 
         
    }
    
    
    public RegResultadosControlador getControlador(){
        return this;
    }
    
    public void actualizarTabla(){
        limpiarDatos();
        this.regResultadosView.llenaGrilla(simulacion,listaEmpleadoxMaquina,arregloEmpleados);
        //actualiza lista de Trabajos
    }
    
    public int getIdProducto(Trabajo trabajo, ArrayList<Empleadoxmaquinasimulacion> arreglo){
        int producto=0;
        for (int i=0; i<arreglo.size();i++){
            if (arreglo.get(i).getEmpleado().getIdempleado()==trabajo.getEmpleado().getIdempleado()){
                producto=arreglo.get(i).getTipoproducto().getIdtipoproducto();
            }
        }
        return producto;       
    }
       
    class guardarListener implements ActionListener {
        
        @Override
        public void actionPerformed(ActionEvent e) {
            ProduccionDAO dao= new ProduccionDAO();
            //simulacion.setEstado(7);//finalizado
            SimulacionDAO dao2= new SimulacionDAO();
           // dao2.guardarSimulacion(simulacion);
            if (verificarTablaProduccionReal(listaEmpleadoxMaquina)==1){
                guardarProduccionReal(listaEmpleadoxMaquina);//captura los resultados puestos en la tabla
                guardarOperacionTotal(listaEmpleadoxMaquina,simulacion);//este guardo     
                regResultadosView.mostrarAviso("Se guardo exitosamente el registro de produccion");    
                regResultadosView.dispose();
            }
            else{
                regResultadosView.mostrarError("Debe llenar todo el registro");
            }          
            //dao.guardarPedidoProduccion(pedidoproduccion);
            //regResultadosView.dispose();          
        }       
    }
    
    private int verificarTablaProduccionReal(ArrayList<Empleadoxmaquinasimulacion> lista){
        int res=1;
        for (int i=0;i<lista.size();i++){
            if ((regResultadosView.getTabla().getValueAt(i, 3)==null) || (regResultadosView.getTabla().getValueAt(i, 4)==null)){
                res=0;             
            }      
        }
        return res;  
    }
    
    public void guardarProduccionReal(ArrayList<Empleadoxmaquinasimulacion> lista){
        for (int i=0;i<lista.size();i++){
            //((DefaultTableModel) regResultadosView.getTabla().getModel()).setRowCount(regResultadosView.getTabla().getRowCount()+1); 
            Integer prod = (Integer)regResultadosView.getTabla().getValueAt(i, 3);
            Integer merma = (Integer)regResultadosView.getTabla().getValueAt(i, 4);
            System.out.println("PRODUCTO ES: "+prod+" MERMA ES:"+merma);
            lista.get(i).setProdReal(prod);
            lista.get(i).setMermaReal(merma);
        }
    }
    
    
    class cerrarListener implements ActionListener {
        
        @Override
        public void actionPerformed(ActionEvent e) {
            
            regResultadosView.dispose();
        }
        
    }
    
    
    
    public void limpiarDatos() {
        ((DefaultTableModel) regResultadosView.getTabla().getModel()).setRowCount(0);
    }
    
    
    public  void guardarProduccionreal(ArrayList<Empleadoxmaquinasimulacion> registros, Simulacion simu){//recive el arreglo de operarios asignados, guarda su produccion, actualiza inentarios, actualiza pedidoproduccion 
        int prod_nor_hor  =0;  
        int mer_nor_hot =0;
        int prod_nor_emp =0;
        int mer_nor_emp=0;
        int prod_dec_hor=0;
        int mer_dec_hor=0;
        int prod_dec_dec=0;
        int mer_dec_dec=0;
        int prod_dec_emp=0;
        int mer_dec_emp=0;
        int prod_rel_hor=0;
        int mer_rel_hor=0;
        int prod_rel_rel=0;
        int mer_rel_rel=0;
        int prod_rel_emp=0;
        int mer_rel_emp=0;
        
        ProduccionDAO pdao = new ProduccionDAO();
        SimulacionDAO sdao = new SimulacionDAO();
        RRHHDAO rhdao = new RRHHDAO();
       
        Date fecha = new Date();
        
        for (int i=0; i < registros.size();i++){
             Empleadoxmaquinasimulacion reg = new   Empleadoxmaquinasimulacion();  
             reg  = registros.get(i);
            int tipomaquina = reg.getMaquina().getTipomaquina().getIdtipomaquina();
            int tipoproducto = reg.getTipoproducto().getIdtipoproducto();
            Historico hist = new Historico();
            
            hist.setFecha(fecha);
            hist.setEmpleado(reg.getEmpleado());
            hist.setTipomaquina(reg.getMaquina().getTipomaquina());
            hist.setTurno(reg.getSimulacion().getTurno());
            hist.setProduccion(reg.getProdReal()/30);
            hist.setMerma(reg.getMermaReal()/30);
            pdao.guardarHistorico(hist);
            
            
            if(tipoproducto == 1){
                switch (tipomaquina){
                    
                    case 1: 
                            if(reg.getProdReal()!= null) prod_nor_hor = prod_nor_hor + reg.getProdReal();
                            if(reg.getMermaReal()!= null) mer_nor_hot = mer_nor_hot + reg.getMermaReal();
                            
                            break;
                        
                    case 4:  if(reg.getProdReal()!= null) prod_nor_emp = prod_nor_emp + reg.getProdReal();
                               if(reg.getMermaReal()!= null) mer_nor_emp = mer_nor_emp + reg.getMermaReal();
                }
            }
            else if ( tipoproducto == 2) {
                 switch (tipomaquina){
                    case 1: if(reg.getProdReal()!= null)prod_dec_hor = prod_dec_hor + reg.getProdReal();
                           if(reg.getMermaReal()!= null)  mer_dec_hor = mer_dec_hor + reg.getMermaReal();
                                    break;
                    case 2:  if(reg.getProdReal()!= null)  prod_dec_dec = prod_dec_dec + reg.getProdReal();
                              if(reg.getMermaReal()!= null)   mer_dec_dec = mer_dec_dec + reg.getMermaReal();
                                        break;
                    case 4:  if(reg.getProdReal()!= null)  prod_dec_emp = prod_dec_emp + reg.getProdReal();
                              if(reg.getMermaReal()!= null)   mer_dec_emp = mer_dec_emp + reg.getMermaReal();
                }
            }
            else if (tipoproducto == 3){
             switch (tipomaquina){
                    case 1:
                      if(reg.getProdReal()!= null)  prod_rel_hor  = prod_rel_hor + reg.getProdReal();
                        if(reg.getMermaReal()!= null)  mer_rel_hor = mer_rel_hor + reg.getMermaReal();
                                 break;
                    case 3:  if(reg.getProdReal()!= null) prod_rel_rel = prod_rel_rel + reg.getProdReal();
                           if(reg.getMermaReal()!= null)  mer_rel_rel = mer_rel_rel + reg.getMermaReal();
                                    break;
                    case 4:    
                     if(reg.getProdReal()!= null)    prod_rel_emp = prod_rel_emp + reg.getProdReal();
                         if(reg.getMermaReal()!= null)        mer_rel_emp= mer_rel_emp + reg.getMermaReal();
                }
            
            }
              //actualizar los estados de los empleados
            reg.getEmpleado().setEstado(1);
            sdao.guardarEmpxmaqsimu(reg);//preguntar si lo esta guardando
            
            rhdao.guardarEmpleado(reg.getEmpleado());
        }//guardar los resultados de la produccion y nuevos inventarios
            
           
            Date date = new Date();
            Calendar cal = Calendar.getInstance();
            cal.setTime(date);
            cal.add(Calendar.DATE,7); // fecha de caducacion
            date = cal.getTime();
            
            SimpleDateFormat dateformatfecha = new SimpleDateFormat("dd/MM/yyyy");
            SimpleDateFormat dateformathora = new SimpleDateFormat("HH:mm:ss");
            Date datefecha = new Date();
                    Date datehora = new Date();
           try{
             datefecha = dateformatfecha.parse(dateformatfecha.format(date));
             datehora = dateformathora.parse(dateformathora.format(date));
           }
           catch(ParseException ex){
           
           }
                    int cantidadInv =0;
           TipoProductoDAO tpdao = new TipoProductoDAO();
           Pedidoproduccion pedido = new Pedidoproduccion();
                
           
           pedido = pdao.getpedBySimByProd( simu.getIdsimulacion(), 9 );
           if(pedido.getIdpedidoproduccion() != 0)
           {
            Productosimulacion prod = new Productosimulacion(); 
            Productointermedio prodint = new Productointermedio();
            
            prod=pdao.getProductoSimulacion(4, simu.getIdsimulacion());
            prod.setProdReal(prod_nor_hor);
            prod.setMermaReal(mer_nor_hot);
            //System.out.println("VALORES "+prod.getSimulacion().getIdsimulacion()+" "+prod.getTipoproducto()+" "+prod.getCantProducida());
            sdao.guardarProdSim(prod);
            //actualizo el inv inicial del producto intermedio
            prodint = sdao.getprodInt(4);
            cantidadInv = prod_nor_hor - prod_nor_emp;
              if(prod_nor_emp > prod_nor_hor) cantidadInv =0;
            prodint.setVolumen(prodint.getTipoproductoByIdtipoproducto1().getFactorVol()*cantidadInv+prodint.getVolumen());
            prodint.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint);
            
            if(cantidadInv >0){//si no fue consumido todo el prdint se registra el ingreso
            Kardex kardex1 = new Kardex();
            kardex1.setAlmacen(prodint.getAlmacen());
            kardex1.setCantidad((long)cantidadInv);
            kardex1.setEntradasalida('E');
            kardex1.setMotivo("Ingreso Producto Intermedio");
            kardex1.setTipoproducto(prod.getTipoproducto());
             kardex1.setTipo("PI");
             kardex1.setEstado(1);
            kardex1.setFecha(datefecha);
            kardex1.setHora(datehora);
            pdao.guardarAjuste(kardex1);
            }
            Productosimulacion prod2 = new Productosimulacion(); 
            Productointermedio prodint2 = new Productointermedio();
           // Materiaprima materia2 = new Materiaprima();
            
            prod2 = pdao.getProductoSimulacion(9, simu.getIdsimulacion());
            prod2.setProdReal(prod_nor_emp);
            prod2.setMermaReal(mer_nor_emp);
            sdao.guardarProdSim(prod2);
            
             prodint2 = sdao.getprodInt(9);
             
            prodint2.setVolumen(prodint2.getTipoproductoByIdtipoproducto1().getFactorVol()*prod_nor_emp+prodint2.getVolumen());
            prodint2.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint2);
            
            Kardex kardex2 = new Kardex();//registroel ingreso del producto intermedio final, este siempre va a entrar
            kardex2.setAlmacen(prodint2.getAlmacen());
            kardex2.setCantidad((long)prod_nor_emp);
            kardex2.setEntradasalida('E');
            kardex2.setMotivo("Ingreso Producto Intermedio");
            kardex2.setTipoproducto(prod2.getTipoproducto());
            kardex2.setTipo("PI");
            kardex2.setEstado(1);
            kardex2.setFecha(datefecha);
            kardex2.setHora(datehora);   
            pdao.guardarAjuste(kardex2);
            
            ArrayList<RecetaPfMp> listaReceta = new ArrayList();
            listaReceta = tpdao.getRecetaByProd(1);
           
            if(!listaReceta.isEmpty()){
               
            for(int i =0;i < listaReceta.size();i++){
                
//                Materiaprima matprim = new Materiaprima();
//                Tipoproducto tipoprod = new Tipoproducto();
             Tipoproducto   tipoprod = tpdao.buscarTipoProducto2(listaReceta.get(i).getTipoproductoByIdtipoproductoMp());
              Materiaprima  matprim=    tpdao.getMateriaPrima(tipoprod.getIdtipoproducto());
                    
                    
                if(matprim.getIdmateriaprima()!=0) {
                    if(matprim.getCantidad()!=0){
                     Kardex kardex = new Kardex();
                       float nuevacant = matprim.getCantidad()- (prod_nor_emp)*listaReceta.get(i).getCantidad(); //hallo la cantidad que se utilizo realmente
                       kardex.setCantidad((long)(prod_nor_emp*listaReceta.get(i).getCantidad()));
                       
                        if(nuevacant<0){
                         nuevacant=0;
                         kardex .setCantidad((long)matprim.getCantidad());
                        }
                        matprim.setCantidad(Math.round(nuevacant));
                     
                     kardex.setAlmacen(matprim.getAlmacen());
                    
                     kardex.setEntradasalida('S');
                     kardex.setMotivo("Salida Materia Prima");
                     kardex.setTipoproducto(tipoprod);
                     kardex.setTipo("MP");
                     kardex.setEstado(1);
                     kardex.setFecha(datefecha);
                     kardex.setHora(datehora);
//                    System.out.println("MIIIIIIIRAMEE:"+matprim.getAlmacen().getIdalmacen()+" "+matprim.getCantidad());
//                    System.out.println("MIIIIIIIRAMEE kardex:"+kardex.getAlmacen().getIdalmacen()+" "+kardex.getCantidad()+" "+kardex.getTipoproducto().getIdtipoproducto());
                     
                    pdao.guardarMP(matprim);
                      pdao.guardarAjuste(kardex);///no guardar el nuevo kardez
                    }
                }
                }
            }
            
             pedido.setCantidadCubierta((float)prod_nor_emp);
            pedido.setEstado(3);//atendida
            pdao.guardarPedidoProduccion(pedido);
            
           }
           
           Pedidoproduccion pedido2 = new Pedidoproduccion();
           pedido2 = pdao.getpedBySimByProd( simu.getIdsimulacion(), 10 );
            
           
           if(pedido2.getIdpedidoproduccion()!=0){
                Productosimulacion prod3 = new Productosimulacion(); 
            Productointermedio prodint3 = new Productointermedio();
            prod3 =  pdao.getProductoSimulacion(5, simu.getIdsimulacion());
            prod3.setProdReal(prod_dec_hor);
            prod3.setMermaReal(mer_dec_hor);
            sdao.guardarProdSim(prod3);
            
            cantidadInv = prod_dec_hor - prod_dec_dec;
            if(prod_dec_dec > prod_dec_hor) cantidadInv =0;
            prodint3 = sdao.getprodInt(5);
            prodint3.setVolumen(prodint3.getTipoproductoByIdtipoproducto1().getFactorVol()*cantidadInv+prodint3.getVolumen());
            prodint3.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint3);
            
            if(cantidadInv>0){
             Kardex kardex3 = new Kardex();
            kardex3.setAlmacen(prodint3.getAlmacen());
            kardex3.setCantidad((long)cantidadInv);
            kardex3.setEntradasalida('E');
            kardex3.setMotivo("Ingreso Producto Intermedio");
            kardex3.setTipoproducto(prod3.getTipoproducto());
            kardex3.setTipo("PI");
            kardex3.setEstado(1);
            kardex3.setFecha(datefecha);
            kardex3.setHora(datehora);
            pdao.guardarAjuste(kardex3);
            }
            
            Productosimulacion prod4 = new Productosimulacion(); 
            Productointermedio prodint4 = new Productointermedio();
            
            prod4 =  pdao.getProductoSimulacion(7, simu.getIdsimulacion());
            prod4.setProdReal(prod_dec_dec);
            prod4.setMermaReal(mer_dec_dec);
            sdao.guardarProdSim(prod4);
            
            cantidadInv =  prod_dec_dec - prod_dec_emp;
            if(prod_dec_emp > prod_dec_dec) cantidadInv =0;
            prodint4 = sdao.getprodInt(7);
            prodint4.setVolumen(prodint4.getTipoproductoByIdtipoproducto1().getFactorVol()*cantidadInv+prodint4.getVolumen());
            prodint4.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint4);
            
            if(cantidadInv>0){
             Kardex kardex4 = new Kardex();
            kardex4.setAlmacen(prodint4.getAlmacen());
            kardex4.setCantidad((long)cantidadInv);
            kardex4.setEntradasalida('E');
            kardex4.setMotivo("Ingreso Producto Intermedio");
            kardex4.setTipoproducto(prod4.getTipoproducto());
             kardex4.setTipo("PI");
             kardex4.setEstado(1);
            kardex4.setFecha(datefecha);
            kardex4.setHora(datehora);
            pdao.guardarAjuste(kardex4);
            }
            
            Productosimulacion prod5 = new Productosimulacion(); 
            Productointermedio prodint5 = new Productointermedio();
            
            prod5 =  pdao.getProductoSimulacion(10, simu.getIdsimulacion());
            prod5.setProdReal(prod_dec_emp);
            prod5.setMermaReal(mer_dec_emp);
            sdao.guardarProdSim(prod5);
           
            prodint5 = sdao.getprodInt(10);
            prodint5.setVolumen(prodint5.getTipoproductoByIdtipoproducto1().getFactorVol()*prod_dec_emp+prodint5.getVolumen());
            prodint5.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint5);
            
            Kardex kardex5 = new Kardex();
            kardex5.setAlmacen(prodint5.getAlmacen());
            kardex5.setCantidad((long)prod_dec_emp);
            kardex5.setEntradasalida('E');
            kardex5.setMotivo("Ingreso Producto Intermedio");
            kardex5.setTipoproducto(prod5.getTipoproducto());
            kardex5.setTipo("PI");
            kardex5.setEstado(1);
            kardex5.setFecha(datefecha);
            kardex5.setHora(datehora);
            pdao.guardarAjuste(kardex5);
            
            ArrayList<RecetaPfMp> listaReceta2 = new ArrayList();
            listaReceta2 = tpdao.getRecetaByProd(2);
            if(!listaReceta2.isEmpty()){
                for(int i =0;i < listaReceta2.size();i++){
                     Materiaprima matprim = new Materiaprima();
                     Tipoproducto tipoprod = new Tipoproducto();
                     tipoprod = tpdao.buscarTipoProducto2(listaReceta2.get(i).getTipoproductoByIdtipoproductoMp());
                     matprim=    tpdao.getMateriaPrima(tipoprod.getIdtipoproducto());
                   if(matprim.getIdmateriaprima()!=0){
                       if(matprim.getCantidad()!=0){
                        Kardex kardexmp = new Kardex();
                        float nuevacant = matprim.getCantidad()- (prod_dec_emp)*listaReceta2.get(i).getCantidad(); 
                        kardexmp.setCantidad((long)(prod_dec_emp*listaReceta2.get(i).getCantidad()));
                        if(nuevacant<0){
                            nuevacant=0;
                            kardexmp.setCantidad((long)matprim.getCantidad());
                        }
                        matprim.setCantidad(Math.round(nuevacant));
                        kardexmp.setAlmacen(matprim.getAlmacen());
                     
                        kardexmp.setEntradasalida('S');
                        kardexmp.setMotivo("Salida Materia Prima");
                        kardexmp.setTipoproducto(tipoprod);
                        kardexmp.setTipo("MP");
                        kardexmp.setEstado(1);
                        kardexmp.setFecha(datefecha);
                        kardexmp.setHora(datehora);
                        pdao.guardarAjuste(kardexmp);
                        pdao.guardarMP(matprim);
                        }
                   }
                    }
                }   
            
            pedido2.setCantidadCubierta((float)prod_dec_emp);
            pedido2.setEstado(3);
            pdao.guardarPedidoProduccion(pedido2);
            
           }
            Pedidoproduccion pedido3 = new Pedidoproduccion();
            pedido3 = pdao.getpedBySimByProd( simu.getIdsimulacion(), 11 );
           if(pedido3.getIdpedidoproduccion()!=0){
           
                Productosimulacion prod6 = new Productosimulacion(); 
            Productointermedio prodint6 = new Productointermedio();
            prod6 =  pdao.getProductoSimulacion(6, simu.getIdsimulacion());
            prod6.setProdReal(prod_rel_hor);
            prod6.setMermaReal(mer_rel_hor);
            sdao.guardarProdSim(prod6);
            
            cantidadInv = prod_rel_hor - prod_rel_rel;
            if(prod_rel_rel>prod_rel_hor) cantidadInv =0;
            prodint6 = sdao.getprodInt(6);
            prodint6.setVolumen(prodint6.getTipoproductoByIdtipoproducto1().getFactorVol()*cantidadInv+prodint6.getVolumen());
            prodint6.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint6);
            
            if(cantidadInv >0){
            Kardex kardex6 = new Kardex();
            
            kardex6.setAlmacen(prodint6.getAlmacen());
            kardex6.setCantidad((long)cantidadInv);
            kardex6.setEntradasalida('E');
            kardex6.setMotivo("Ingreso Producto Intermedio");
            kardex6.setTipoproducto(prod6.getTipoproducto());
            kardex6.setTipo("PI");
            kardex6.setEstado(1);
            kardex6.setFecha(datefecha);
            kardex6.setHora(datehora);
            pdao.guardarAjuste(kardex6);
            }
            
             Productosimulacion prod7 = new Productosimulacion(); 
            Productointermedio prodint7 = new Productointermedio();
            prod7 =  pdao.getProductoSimulacion(8, simu.getIdsimulacion());
            prod7.setProdReal(prod_rel_rel);
            prod7.setMermaReal(mer_rel_rel);
            sdao.guardarProdSim(prod7);
            
            cantidadInv = prod_rel_rel - prod_rel_emp;
            if(prod_rel_emp > prod_rel_rel) cantidadInv=0;
            prodint7 = sdao.getprodInt(8);
            prodint7.setVolumen(prodint7.getTipoproductoByIdtipoproducto1().getFactorVol()*cantidadInv+prodint7.getVolumen());
            prodint7.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint7);
            
            if(cantidadInv>0){
            Kardex kardex7 = new Kardex();
            kardex7.setAlmacen(prodint7.getAlmacen());
            kardex7.setCantidad((long)cantidadInv);
            kardex7.setEntradasalida('E');
            kardex7.setMotivo("Ingreso Producto Intermedio");
            kardex7.setTipoproducto(prod7.getTipoproducto());
            kardex7.setTipo("PI");
            kardex7.setEstado(1);
            kardex7.setFecha(datefecha);
            kardex7.setHora(datehora);
            pdao.guardarAjuste(kardex7);
            }
            
             Productosimulacion prod8 = new Productosimulacion(); 
            Productointermedio prodint8 = new Productointermedio();
            
            prod8 =  pdao.getProductoSimulacion(11, simu.getIdsimulacion());
            prod8.setProdReal(prod_rel_emp);
            prod8.setMermaReal(mer_rel_emp);
            sdao.guardarProdSim(prod8);
            
            prodint8 = sdao.getprodInt(11);
            prodint8.setVolumen(prodint8.getTipoproductoByIdtipoproducto1().getFactorVol()*prod_rel_emp+prodint8.getVolumen());
            prodint8.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint8);
            Kardex kardex8 = new Kardex();
            
            kardex8.setAlmacen(prodint8.getAlmacen());
            kardex8.setCantidad((long)prod_rel_emp);
            kardex8.setEntradasalida('E');
            kardex8.setMotivo("Ingreso Producto Intermedio");
            kardex8.setTipoproducto(prod8.getTipoproducto());
            kardex8.setTipo("PI");
            kardex8.setFecha(datefecha);
            kardex8.setEstado(1);
            kardex8.setHora(datehora);
            pdao.guardarAjuste(kardex8);
            
            
            ArrayList<RecetaPfMp> listaReceta3 = new ArrayList();
            listaReceta3 = tpdao.getRecetaByProd(3);
            if(!listaReceta3.isEmpty()){
                for(int i =0;i < listaReceta3.size();i++){
                    
            Materiaprima matprim = new Materiaprima();
            Tipoproducto tipoprod = new Tipoproducto();
                     tipoprod = tpdao.buscarTipoProducto2(listaReceta3.get(i).getTipoproductoByIdtipoproductoMp());
                     matprim=    tpdao.getMateriaPrima(tipoprod.getIdtipoproducto());
                   //  System.out.println("LEEEEEMEEE: "+matprim.getIdmateriaprima()+" and"+matprim.getVolumen());
                  if(matprim.getIdmateriaprima()!=0){
                      if(matprim.getCantidad()!=0){
                       Kardex kardexmp = new Kardex();
                    float nuevacant = matprim.getCantidad()- (prod_rel_emp)*listaReceta3.get(i).getCantidad(); 
                     kardexmp.setCantidad((long)(prod_rel_emp*listaReceta3.get(i).getCantidad()));
                    if(nuevacant<0){
                        nuevacant=0;
                        kardexmp.setCantidad((long)matprim.getCantidad());
                    }
                   matprim.setCantidad(Math.round(nuevacant));
                     kardexmp.setAlmacen(matprim.getAlmacen());
                    
                     kardexmp.setEntradasalida('S');
                     kardexmp.setMotivo("Salida Materia Prima");
                     kardexmp.setTipoproducto(tipoprod);
                     kardexmp.setTipo("MP");
                     kardexmp.setFecha(datefecha);
                     kardexmp.setEstado(1);
                      kardexmp.setHora(datehora);
                      pdao.guardarMP(matprim);
                 pdao.guardarAjuste(kardexmp);
                      }
                  }
                }
            }
            
            pedido3.setCantidadCubierta((float)prod_rel_emp);
            pedido3.setEstado(3);
            pdao.guardarPedidoProduccion(pedido3);
            
           }
            simu.setEstado(7);// actualizar estado a utilizado
            sdao.guardarSimulacion(simu);
            
            
    }
    
    public void registrarProdDemanda( Simulacion simu){//actualiza demanda
            Demanda demanda = new Demanda();
            ProduccionDAO pdao = new ProduccionDAO();
            
            int prod_nor_emp =0;
            int prod_dec_emp =0;
            int prod_rel_emp =0;
            
            prod_nor_emp = pdao.getProductoSimulacion(9, simu.getIdsimulacion()).getProdReal();
            prod_dec_emp = pdao.getProductoSimulacion(10, simu.getIdsimulacion()).getProdReal();
            prod_rel_emp = pdao.getProductoSimulacion(11, simu.getIdsimulacion()).getProdReal();
            
            Date date = new Date();
            //SimpleDateFormat dateformatfecha = new SimpleDateFormat("dd/MM/yyyy");
            SimpleDateFormat dateformathora = new SimpleDateFormat("HH:mm:ss");
            Date datefecha = new Date();
                    Date datehora = new Date();
           try{
           //  datefecha = dateformatfecha.parse(dateformatfecha.format(date));
             datehora = dateformathora.parse(dateformathora.format(date));
           }
           catch(ParseException ex){
           
           }
            
            demanda = pdao.getDemandasBySimulacion(simu);
            demanda.setCrealNormal(prod_nor_emp);
            demanda.setCrealPed(prod_dec_emp);
            demanda.setCrealRell(prod_rel_emp);
            demanda.setEstado(2);//estado atendido
            demanda.setFecha(datefecha);
            pdao.guardarDemanda(demanda);
            
             //actualizaremos los productos finales y pedidos producto
            SimulacionDAO sdao = new SimulacionDAO();
           TipoProductoDAO tpdao = new TipoProductoDAO();
            
            ArrayList<Demandaxpedidoproducto> listapedidos = new ArrayList();
            listapedidos = sdao.getPedidosProductoxdemanda(demanda.getIddemanda());//obtengo los peiddos relacionados a la demanda
            
            int cant_normal = demanda.getCrealNormal();
            int cant_dec = demanda.getCrealPed();
            int  cant_rel = demanda.getCrealRell();
            int auxnormal = cant_normal;
            int auxdec = cant_dec;
            int auxrel = cant_rel;
            ArrayList<Presentacion> listapre = new ArrayList();
            listapre = pdao.getPresentaciones();
            int[][] matriz = new int[3][listapre.size()];        
            
            int cantCubrir = 0;
            Presentacion  presentacion = new Presentacion();
            
         for(int i =0;i < listapedidos.size();i++){
              ArrayList<Lineapedidoproducto> lineapedido = new ArrayList(); 
              lineapedido = pdao.getlineasByPedido(listapedidos.get(i).getPedidoproducto().getIdpedidoproducto());
              
              for(int j=0; j < lineapedido.size() ;j++){
                 Lineapedidoproducto linea = new Lineapedidoproducto();
                 linea = lineapedido.get(j);
                  presentacion = linea.getPresentacion();
                  
                  Productofinal prodfin = new Productofinal();
                  int cantdiv =0;
                  cantCubrir=0;
                  try {//calculo la cantidad a cubrir en unidades
                      cantCubrir = (int)((linea.getCantidad()*presentacion.getCantidad()- linea.getCantidadCubierta())*presentacion.getCantidad());
                  } catch (Exception e) {
                      System.out.println(e.toString());
                  }
              
                  
                  
                  if(cantCubrir>0 ){
                          
                  switch(linea.getTipoproducto().getIdtipoproducto()){
                      
                      case 1: if(cant_normal> cantCubrir){
 
                                    cant_normal = cant_normal - cantCubrir;
                                    linea.setCantidadCubierta(Math.round((linea.getCantidad())));
                                    matriz[0][presentacion.getIdpresentacion()]= matriz[0][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                    prodfin = pdao.getProductoFinal(1 ,presentacion.getIdpresentacion());
                                    prodfin.setCantidad(prodfin.getCantidad()+linea.getCantidadCubierta());
                                    pdao.guardarProductoFinal(prodfin);
                              } else{
                                cantdiv = cant_normal/presentacion.getCantidad();//hallo la cantidad del producto que puedo cubrir en esa presentacion
                                    if(cantdiv >0){
                                            cant_normal = cant_normal - cantdiv*presentacion.getCantidad();
                                            linea.setCantidadCubierta(Math.round(linea.getCantidad()+cantdiv));
                                    matriz[0][presentacion.getIdpresentacion()]= matriz[0][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                            prodfin = pdao.getProductoFinal(1 ,presentacion.getIdpresentacion());
                                            prodfin.setCantidad(prodfin.getCantidad()+cantdiv);
                                            pdao.guardarProductoFinal(prodfin);
                                    }
                                
                                }
                                break;
                      case 2:if(cant_dec> cantCubrir){
 
                                    cant_dec = cant_dec - cantCubrir;
                                    linea.setCantidadCubierta(Math.round((linea.getCantidad())));
                                    matriz[1][presentacion.getIdpresentacion()]= matriz[1][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                    prodfin = pdao.getProductoFinal(2 ,presentacion.getIdpresentacion());
                                    prodfin.setCantidad(prodfin.getCantidad()+linea.getCantidadCubierta());
                                    pdao.guardarProductoFinal(prodfin);
                              } else{
                                cantdiv = cant_dec/presentacion.getCantidad();
                                    if(cantdiv >0){
                                            cant_dec = cant_dec - cantdiv*presentacion.getCantidad();
                                             linea.setCantidadCubierta(Math.round((linea.getCantidad()+cantdiv)));
                                    matriz[1][presentacion.getIdpresentacion()]= matriz[1][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                           
                                            prodfin = pdao.getProductoFinal(2 ,presentacion.getIdpresentacion());
                                            prodfin.setCantidad(prodfin.getCantidad()+cantdiv);
                                            pdao.guardarProductoFinal(prodfin);
                                    }
                                
                                }
                             break;
                      case 3: if(cant_rel> cantCubrir){
 
                                    cant_rel = cant_rel - cantCubrir;
                                    linea.setCantidadCubierta(Math.round((linea.getCantidad())));
                                    matriz[2][presentacion.getIdpresentacion()]= matriz[2][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                    prodfin = pdao.getProductoFinal(3 ,presentacion.getIdpresentacion());
                                    prodfin.setCantidad(prodfin.getCantidad()+linea.getCantidadCubierta());
                                    pdao.guardarProductoFinal(prodfin);
                              } else{
                                cantdiv = cant_rel/presentacion.getCantidad();
                                    if(cantdiv >0){
                                            cant_rel = cant_rel - cantdiv*presentacion.getCantidad();
                                            linea.setCantidadCubierta(Math.round((linea.getCantidad()+cantdiv)));
                                            matriz[2][presentacion.getIdpresentacion()]= matriz[2][presentacion.getIdpresentacion()]+ linea.getCantidadCubierta();
                                            prodfin = pdao.getProductoFinal(3 ,presentacion.getIdpresentacion());
                                            prodfin.setCantidad(prodfin.getCantidad()+cantdiv);
                                            pdao.guardarProductoFinal(prodfin);
                                    }
                                
                                }  
                                pdao.guardarlinea(linea);
                  }
                  
                  
                }
                 
              }
            }
         
         if(cant_normal < auxnormal){
            Productointermedio prodint = new Productointermedio();
            prodint = sdao.getprodInt(9);
            prodint.setVolumen(prodint.getVolumen()-prodint.getTipoproductoByIdtipoproducto1().getFactorVol()*(auxnormal-cant_normal));
            prodint.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint);
            
            Kardex kardex = new Kardex();
            
            kardex.setAlmacen(prodint.getAlmacen());
            kardex.setCantidad((long)(auxnormal-cant_normal));
            kardex.setEntradasalida('S');
            kardex.setMotivo("Salida Producto Intermedio");
            kardex.setTipoproducto(prodint.getTipoproductoByIdtipoproducto2());
            kardex.setTipo("PI");
            kardex.setEstado(1);
            kardex.setFecha(datefecha);
            kardex.setHora(datehora);
            pdao.guardarAjuste(kardex);
         }
         if(cant_dec < auxdec){
            Productointermedio prodint = new Productointermedio();
            prodint = sdao.getprodInt(10);
            prodint.setVolumen(prodint.getVolumen()-prodint.getTipoproductoByIdtipoproducto1().getFactorVol()*(auxdec-cant_dec));
            prodint.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint);
            
            Kardex kardex = new Kardex();
            
            kardex.setAlmacen(prodint.getAlmacen());
            kardex.setCantidad((long)(auxnormal-cant_normal));
            kardex.setEntradasalida('S');
            kardex.setMotivo("Salida Producto Intermedio");
            kardex.setTipoproducto(prodint.getTipoproductoByIdtipoproducto2());
            kardex.setTipo("PI");
            kardex.setFecha(datefecha);
            kardex.setEstado(1);
            kardex.setHora(datehora);
            pdao.guardarAjuste(kardex);
         }
         if(cant_rel < auxrel){
            Productointermedio prodint = new Productointermedio();
            prodint = sdao.getprodInt(11);
            prodint.setVolumen(prodint.getVolumen()-prodint.getTipoproductoByIdtipoproducto1().getFactorVol()*(auxrel-cant_rel));
            prodint.setFechaCaducidad(date );
            pdao.guardarProductoIntermedio(prodint);
            
            Kardex kardex = new Kardex();
            kardex.setAlmacen(prodint.getAlmacen());
            kardex.setCantidad((long)(auxnormal-cant_normal));
            kardex.setEntradasalida('S');
            kardex.setMotivo("Salida Producto Intermedio");
            kardex.setTipoproducto(prodint.getTipoproductoByIdtipoproducto2());
            kardex.setTipo("PI");
            kardex.setEstado(1);
            kardex.setFecha(datefecha);
            kardex.setHora(datehora);
            pdao.guardarAjuste(kardex);
         }
         
          Almacen alma = new Almacen();
          alma=pdao.getAlmacen(3);
          for(int i=0;i < 3 ;i++){
             for(int j=0; j < listapre.size();j++){
                 if(matriz[i][j]>0){
                    Kardex kardexx = new Kardex();
                    Presentacion presenta = pdao.getPresentacion(j+1);
                    Tipoproducto tipopro = sdao.getTipoProductoId(i+1);
                    kardexx.setPresentacion(presenta);
                    kardexx.setTipoproducto(tipopro);
                    kardexx.setAlmacen(alma);
                    kardexx.setEntradasalida('E');
                    kardexx.setEstado(1);
                    kardexx.setFecha(datefecha);
                    kardexx.setHora(datehora);
                    kardexx.setTipo("PF");
                    kardexx.setCantidad((long)matriz[i][j]);
                    kardexx.setMotivo("Ingreso Producto Final");
                    pdao.guardarAjuste(kardexx);
                 }
             }
         }
    }
    
    public void actEmpMaqDis(int idsimu){
        ArrayList<Empleadoxmaquinasimulacion> listaemp = new ArrayList();
            ProduccionDAO pdao = new ProduccionDAO();
            RRHHDAO rdao = new RRHHDAO();
            listaemp = pdao.getEmplexMaq(idsimu);
           for(int i=0; i< listaemp.size(); i++){
               Empleado emp = new Empleado();
               Maquina maq =new Maquina();        
                listaemp.get(i).getEmpleado().setEstado(1);
                listaemp.get(i).getMaquina().setEstado(0);
                emp =listaemp.get(i).getEmpleado();
                maq =listaemp.get(i).getMaquina();
                rdao.guardarEmpleado(emp);
                rdao.guardarMaquinaria(maq);
            }
    }
    
    public void guardarOperacionTotal(ArrayList<Empleadoxmaquinasimulacion> registros, Simulacion simu){
            
        guardarProduccionreal(registros,simu);
        registrarProdDemanda(simu);
        actEmpMaqDis(simu.getIdsimulacion());
    }
    
    
    
    public void leerHistoricos2(ArrayList<EmpleadoAlgoritmo> empleados){
     SimulacionDAO s = new SimulacionDAO();
     for(int i=0; i<empleados.size(); i++){
          int bandera=0;
          EmpleadoAlgoritmo emp = empleados.get(i);
           ArrayList<Historico> historicoemp = s.historiaEmpleado(emp.getIdempleado(), emp.getTurno());//por cada operario obtendre su historico
           int[] produccion = new int[4];
           int[] mermas = new int[4];
           int [] contadores = new int[4];//contara los hisoricos para cada tipo de maquina
           int sumaprod=0;
                int sumamerm = 0;  
           Superhombre superhombre = s.getSuperHombre(emp.getIdempleado());
            if (superhombre.getIdsuperhombre() != 0) {
                if (superhombre.getEstado() == 1) {
                    produccion[0] = superhombre.getProduccionHorneado();
                    produccion[0] = superhombre.getProduccionDecorado();
                    produccion[0] = superhombre.getProduccionRellenado();
                    produccion[0] = superhombre.getProduccionEmpaquetado();
                    mermas[0] = superhombre.getMermaHorneado();
                    mermas[0] = superhombre.getMermaDecorado();
                    mermas[0] = superhombre.getMermaRellenado();
                    mermas[0] = superhombre.getMermaEmpaquetado();
                    bandera = 1;
                }
                bandera = 0;
            }
           if (bandera==0){
           for(int j=0 ; j < historicoemp.size();j++){
               Historico historico = historicoemp.get(j);
               // if(emp.getTurno()==historico.getTurno()){
               switch( historico.getTipomaquina().getIdtipomaquina()){//por cada historico del empleado calculare su promedio de produ y merm
                   case 1:  //observare a que tipo de maquina corresponde esa produccion y merma
                             sumaprod = produccion[0]*contadores[0];
                             sumamerm = mermas[0]*contadores[0];
                            contadores[0] = contadores[0] + 1;
                            produccion[0] = (sumaprod + historico.getProduccion())/contadores[0];//saco el promedio de produccion
                            mermas[0] = (sumamerm+ historico.getMerma())/contadores[0];
                            
                            break;
                   case 2:
                             sumaprod = produccion[1]*contadores[1];
                             sumamerm = mermas[1]*contadores[1];
                            contadores[1] = contadores[1] + 1;
                            produccion[1] = (sumaprod + historico.getProduccion())/contadores[1];
                            mermas[1] = (sumamerm+ historico.getMerma())/contadores[1];
                            break;
                   case 3: 
                             sumaprod = produccion[2]*contadores[2];
                             sumamerm = mermas[2]*contadores[2];
                            
                            contadores[2] = contadores[2] + 1;
                            produccion[2] = (produccion[2] + historico.getProduccion())/contadores[2];
                            mermas[2] = (mermas[2]+ historico.getMerma())/contadores[2];
                            break;
                   case 4:
                            sumaprod = produccion[3]*contadores[3];
                             sumamerm = mermas[3]*contadores[3];
                            contadores[3] = contadores[3] + 1;
                            produccion[3] = (produccion[3] + historico.getProduccion())/contadores[3];
                            mermas[3] = (mermas[3]+ historico.getMerma())/contadores[3];
                
               }
                }
           }
           
          //}
           emp.setProduccion(produccion);
           emp.setMermas(mermas);
           emp.calcularCap(produccion, mermas);
          // this.arregloEmpleadosAlgoritmo.add(emp);
       
     }
    }//fin historico
}
